CU Amiga Super CD-ROM 11/CU Amiga Magazine's Super CD-ROM 11 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-06].iso/cucd/programming/amoslist/amoslist.mar/[e-mail]_Tue Mar 18 18:50:08 1997.msg

Text File | 1997-04-01 | 10KB | 261 lines

Received: from svcs1.digex.net (svcs1.digex.net [204.91.197.224])
    by mail1.access.digex.net (8.8.5/8.8.5) with ESMTP id SAA29014
    for <[e-mail]>; Tue, 18 Mar 1997 18:50:04 -0500 (EST)
Received: (from daemon@localhost)
    by svcs1.digex.net (8.8.5/8.8.5) id QAA03919
    for amos-out; Tue, 18 Mar 1997 16:42:03 -0500 (EST)
Received: from mail1.access.digex.net (mail1.access.digex.net [205.197.247.2])
    by svcs1.digex.net (8.8.5/8.8.5) with ESMTP id QAA03916
    for <[e-mail]>; Tue, 18 Mar 1997 16:42:02 -0500 (EST)
Received: from vifa1.freenet.victoria.bc.ca ([e-mail] [199.60.222.1])
    by mail1.access.digex.net (8.8.5/8.8.5) with ESMTP id QAA18872
    for <[e-mail]>; Tue, 18 Mar 1997 16:41:59 -0500 (EST)
Received: (from uv334@localhost) by vifa1.freenet.victoria.bc.ca (8.7.5/8.7.3) id NAA07908; Tue, 18 Mar 1997 13:42:07 -0800 (PST)
Date: Tue, 18 Mar 1997 13:42:06 -0800 (PST)
From: John Bintz <[e-mail]>
Sender: John Bintz <[e-mail]>
Reply-To: John Bintz <[e-mail]>
Subject: Raycasting for Beginners (was Bending Walls)
To: [e-mail]
Message-ID: <Pine.3.89.9703171320.A5765-0100000@vifa1>
MIME-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Status: RO
X-Status:

Well, Mr. Howarth should be commended for trying a raycaster.  I remember
when I was tring very desparately to figure out how to make one.
Fortunately, I found a book that kinda explained it.  After some work,
though, I finally figured out how to write a fast and accurate ray caster.

The way Lee put it, he wrote a very simple, non-trig version of a
raycaster.  He got the concept of "raycasting" down, its just not useful
the way he coded it.  To hame a truly 3D game (at least a #D
representation of a 2D map), he needs Math.  And, as Sinbad says, "Math
is Power".

Here is a copy of my original "I Have A Few Tricks Up My Sleeve..."
page.  The part about Wolf-3D like raycasters.  If its too big (8k?) then
feel free to complain.  Here it is...

RayCasting and Texture Mapping -- John Bintz, 3D Master  8^)

So, you want to write Doom-like games in your spare time? I'm warning you:
once you know how to do this stuff, you'll probably never write another game
with just 2D graphics again...EVER!

Here is a very loose algorithm for raycasting and texture mapping:

Precompute math tables
Create a map
Create some textures

While your game is running
# For each ray in your field of view
## Cast a ray, detecting horizontal and vertical intersections with blocks
## Find out the shortest distance to yourself
##     from the horizontal & vertical intersections
## Fix the depth of the ray depending on the view angle
## Determine the height of the wall
## Choose a sliver from the texture and zoom it to the appropriate size
# Move the little guy around

Now, I'll describe all of these in excruciating detail:

Precompute Math Tables

For my method of raycasting, you need to know Sines and Cosines of angles.
These are computed by the computer and stored as floating point, which, as all
programmers know, is extremely accurate yet excruciatingly slow. We need to make
them fixed point...not as accurate, but sometimes at least 3 or 4 times
faster.

How many degrees will you have to compute? Well, this will
involve that difficult technique known as the ratio. What you need to know is
the screen resolution horizontally, the number of total angles, and the number
of angles in your viewing plane. Your view plane is the number of angles cast
out from your current position to the walls. If you wanted to stick with easy
stuff, have the number of rays cast out equal to the degrees in your view
plane...fast, but blocky. You can use this formula to find out how many angles
to put into the tables:

Angles=(360*Rays to cast)/View Angle

If you wanted to fill all the lines on the screen, the formula would look
like this:

Angles=(360*320)/60

Giving the result of 1920 angles.

You could use floating point math to find out how much each angle
will actually measure from 0 to 359, but you can do that on your own.

Fixing the angles simply requires you to multiply the floating point number by a
fixed point number, therefore making another fixed point number. I like using
512, just for the heck of it. Fill your table with fixed trig numbers, and move
on to Step 2...

Create A Map

This shouldn't be too hard--just an array of elements you can fill with any numbers you want...have
them correspond to the texture to map to the walls, or the light level of each
wall. Just make empty space a value of zero.

Cast A Ray

This is where you can pretty much think of your own way to do things. Here's an
example from QBasic (ICK! GAG!! RETCH!!!) that is pretty good. It should be
readily convertable to other languages, Amos Basic being the most obvious:

FUNCTION newcast (x, y, ang)

angle = (ang + 360) MOD 360
corner = 0
'
'Some Readily Used Values
'

IF ang > 90 AND ang
  yadj = halfbsize
ELSE
  yadj = -halfbsize
END IF
IF ang > 0 AND ang
  xadj = halfbsize
ELSE
  xadj = -halfbsize
END IF
'
'This is the X Casting.  It looks for intersections on the X (horizontal) axis.
'
IF gcos(angle) = 0 THEN
  xdepth = 1E+10
ELSE
  IF ang > 90 AND ang
    ybound = INT(y / bsize) * bsize + bsize
    ydelta = bsize
  ELSE
    ybound = INT(y / bsize) * bsize
    ydelta = -bsize
  END IF
  casting = -1
  DO
    ydist = ybound - y
    depth = (ydist * 512) / gcos(angle)
    xdist = (depth * gsin(angle)) / 512
    dx = INT((x - xdist) / bsize)
    IF dx >= 0 AND dx
      IF map(dx, INT((ybound + yadj) / bsize)) > 0 THEN
        casting = 0
        xdepth = ABS(depth)
        xsliv = ABS(x - xdist) MOD bsize
      ELSE
        ybound = ybound + ydelta
      END IF
    ELSE
      casting = 0
      xdepth = 1E+10
    END IF
  LOOP UNTIL NOT casting
END IF
'
'The Y Casting Comes Next, looking for Vertical intersections
'
IF gsin(angle) = 0 THEN
  ydepth = 1E+10
ELSE
  IF ang > 0 AND ang
    xbound = INT(x / bsize) * bsize + bsize
    xdelta = bsize
  ELSE
    xbound = INT(x / bsize) * bsize
    xdelta = -bsize
  END IF
  casting = -1
  DO
    xdist = xbound - x
    depth = (xdist * 512) / gsin(angle)
    ydist = (depth * gcos(angle)) / 512
    dy = INT((y - ydist) / bsize)
    IF dy >= 0 AND dy
      IF map(INT((xbound + xadj) / bsize), dy) > 0 THEN
        casting = 0
        ydepth = ABS(depth)
        ysliv = ABS(y - ydist) MOD bsize
      ELSE
        xbound = xbound + xdelta
      END IF
    ELSE
      casting = 0
      ydepth = 1E+10
    END IF
  LOOP UNTIL NOT casting
END IF
'
'This picks which depth to use, depending on which is closest
'
IF xdepth
  newcast = xdepth
  IF xsliv = 0 THEN corner = -1
ELSE
  newcast = ydepth
  IF ysliv = 0 THEN corner = -1
END IF
END FUNCTION

I'm sorry if that wasn't too well explained, but its a very difficult topic
to explain. Just pick up "Tricks of the Game Programming Gurus" by Andrew
LaMothe, and you'll be even more confused!. Try to pick your way through it the
best that you can. If I can hire someone to explain it better, I will;
otherwise, fry some brain cells over my Basic code.

Fix the depth

Any idiot with a major in Mathematics will know there's a slight problem
with this routine. Think about it...OK, enough thinking. Here's the problem:
When you cast your rays out, you're doing it in a circle. When they hit, they're
working in a rectangular plane. The fix? Make your rectangular world a circular
world, or make your circular world a rectangular one. The first one is easier:
Simply multiply the depth by the cosine of the current view angle. If your view
angle is -10 of your current facing angle, and the depth is 35, then you'd
multiply the cosine of -10 (precomputed, I hope!) by 35, and get 34. Big deal!
Try -30 and 60, at the furthest reaches of your view plane. The result is 51, a
very signifigant fix (with two signifigant digits!). But remember: the angle you
use is RELATIVE to the angle your guy is facing. Not to be sexist, but you can
be a girl, too.


Draw the Sliver, with or without Textures

This part is pretty easy compared to the others: You need the fixed depth
and the size of HALF of your wall. To get the new HALF size of your wall, try
this:

New HALF Size=Normal HALF Size/Depth

Now, simply subtract from half your display and add to half your display
that value, and your wall can be plotted. A command like:

Cls 15,X,100-NHS to X+1,100+NHS

will do the trick nicely.

For those who want texture mapping, you should save that XSLIV or YSLIV
value in the code above, as this tells you what sliver on the texture to use. If
your blocks are 64 pixels large, then the sliver value will be from 0 to 63.
Then, simply use a Zoom-like command to put it at its appropriate size:

Zoom 1,SLIV,0,SLIV+1,63 to 0,X,100-NHS,X+1,100+NHS

Hope this helps!

#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@
        John C. Bintz - * [e-mail] *
@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#*@#
Come Visit Internext Software - the home of great Amiga software!
    http://www.dragonfire.net/~JohnBintz/inext/inextsoft.html
*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#@*#